package com.relatev.minecraft.TRAttribute;

import com.relatev.minecraft.TRAttribute.event.TAttributeLoadEvent;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Random;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.LivingEntity;
import org.bukkit.event.HandlerList;
import org.bukkit.plugin.Plugin;
import org.bukkit.scheduler.BukkitTask;

public class AttributeManager {

    private static TRAConfigManager ConfigManager;
    private LinkedHashMap<String, TAttribute> EnabledAttributes = new LinkedHashMap();
    private HashMap<TAttribute, BukkitTask> CacheTaskMap = new HashMap();
    public static AttributeManager Instance;
    private static Random random = new Random();

    public static void init() {
        Instance = new AttributeManager();
        ConfigManager = TRAttribute.mainPlugin.getConfigManager();
    }

    public boolean loadAttribute(TAttribute attr) {
        return loadAttribute(attr.getClass().getSimpleName(), attr);
    }

    public boolean loadAttribute(String id, TAttribute attr) {
        TRAttribute.mainPlugin.getLogger().info("开始加载属性: " + id);
        File configfile = ConfigManager.getAttributeConfigFile(id);
        if (configfile.exists() == false) {
            try {
                configfile.createNewFile();
            } catch (IOException ex) {
                Logger.getLogger(AttributeManager.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        YamlConfiguration config = YamlConfiguration.loadConfiguration(configfile);
        if (config.contains("Enable") == false) {
            config.set("Enable", true);
            config.set("Texts", attr.effectiveTexts);
            try {
                config.save(configfile);
            } catch (IOException ex) {
                Logger.getLogger(AttributeManager.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        if (config.getBoolean("Enable")) {
            attr.effectiveTexts = config.getStringList("Texts");
            TAttributeLoadEvent event = new TAttributeLoadEvent(attr);
            Bukkit.getPluginManager().callEvent(event);
            if (event.isCancelled()) {
                return false;
            }
            EnabledAttributes.put(id, attr);
            attr.onEnable();
            Bukkit.getPluginManager().registerEvents(attr, TRAttribute.mainPlugin);
            CacheTaskMap.put(attr, Bukkit.getScheduler().runTaskTimerAsynchronously(TRAttribute.mainPlugin, attr, ConfigManager.GobalConfig.getInt("CacheClearTickPeriod"), ConfigManager.GobalConfig.getInt("CacheClearTickPeriod")));
            return true;
        } else {
            return false;
        }
    }

    public boolean unloadAttribute(String id) {
        TRAttribute.mainPlugin.getLogger().info("开始卸载属性: " + id);
        TAttribute attr = EnabledAttributes.get(id);
        if (attr == null) {
            return false;
        } else {
            HandlerList.unregisterAll(attr);
            CacheTaskMap.get(attr).cancel();
            attr.onDisable();
            EnabledAttributes.remove(id);
            return true;
        }
    }

    public HashMap<String, TAttribute> getEnabledAttributes() {
        return (LinkedHashMap<String, TAttribute>) EnabledAttributes.clone();
    }

//    private static double solveNumber(String text) {
//        String result = "";
//        text = ChatColor.stripColor(text);
//        String rangechar = YamlConfiguration.loadConfiguration(TRAttribute.MainPlugin.getConfigManager().getGobalConfigFile()).getString("RangeChar");
//        if (text.contains(rangechar)) {
//            String[] vts = text.split(rangechar);
//            double min = solveNumber(vts[0]);
//            double max = solveNumber(vts[1]);
//            return min + random.nextDouble() * (max - min);
//        }
//        for (int i = 0; i < text.length(); i++) {
//            char tc = text.charAt(i);
//            if (tc == '.' || tc == '-' || Character.isDigit(tc)) {
//                result = result + tc;
//            }
//        }
//        if (result.length() == 0) {
//            return 0;
//        }
//        if (text.contains("%")) {
//            return Double.parseDouble(result) / 100;
//        } else {
//            return Double.parseDouble(result);
//        }
//    }

//    @Deprecated
//    public List<AttributeValue> solveTexts(List<String> texts, TAttribute attribute) {
//        List<AttributeValue> values = new ArrayList();
//        for (String text : texts) {
//            for (String at : attribute.EffectiveTexts) {
//                if (text.contains(at)) {
//                    text = text.replace(at, "");
//                    if (text.contains(ConfigManager.MultiplyChar)) {
//                        values.add(new AttributeValue(ValueType.MULTIPLY, solveNumber(text)));
//                    } else if (text.contains(ConfigManager.RateChar)) {
//                        values.add(new AttributeValue(ValueType.RATE, solveNumber(text)));
//                    } else {
//                        values.add(new AttributeValue(ValueType.PLUS, solveNumber(text)));
//                    }
//                }
//            }
//        }
//        return values;
//    }

//    @Deprecated
//    public void loginTexts(LivingEntity lent, List<String> texts, Plugin pl) {
//        for (String id : Instance.EnabledAttributes.keySet()) {
//            TAttribute attribute = Instance.EnabledAttributes.get(id);
//            List<AttributeValue> values = new ArrayList();
//            Iterator<String> it = texts.iterator();
//            while (it.hasNext()) {
//                String text = it.next();
//                for (String at : attribute.EffectiveTexts) {
//                    if (text.contains(at)) {
//                        text = text.replace(at, "");
//                        if (text.contains(ConfigManager.MultiplyChar)) {
//                            values.add(new AttributeValue(ValueType.MULTIPLY, solveNumber(text)));
//                        } else if (text.contains(ConfigManager.RateChar)) {
//                            values.add(new AttributeValue(ValueType.RATE, solveNumber(text)));
//                        } else {
//                            values.add(new AttributeValue(ValueType.PLUS, solveNumber(text)));
//                        }
//                        it.remove();
//                    }
//                }
//            }
//            if (values.isEmpty() == false) {
//                attribute.putValues(lent, values, pl, "AttributeManager.loginTexts");
//            } else {
//                attribute.removeValues(lent, pl, "AttributeManager.loginTexts");
//            }
//        }
//    }
}
